package es.tikitaka.actions.competicion;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.jboss.seam.ScopeType;
import org.jboss.seam.annotations.Begin;
import org.jboss.seam.annotations.End;
import org.jboss.seam.annotations.FlushModeType;
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Scope;
import org.jboss.seam.annotations.datamodel.DataModel;
import org.jboss.seam.annotations.datamodel.DataModelSelection;
import org.jboss.seam.faces.FacesMessages;

import es.tikitaka.dao.CalendarioLigaService;
import es.tikitaka.dao.JornadaService;
import es.tikitaka.dao.LigaService;
import es.tikitaka.dao.PartColegiadoService;
import es.tikitaka.dao.PartEquipoService;
import es.tikitaka.dao.PartidoLService;
import es.tikitaka.dao.SegColegiadoService;
import es.tikitaka.dao.SegEquipoService;
import es.tikitaka.dao.SegJugadorService;
import es.tikitaka.dao.TemporadaService;
import es.tikitaka.domain.Temporada;
import es.tikitaka.domain.colegiado.PartColegiado;
import es.tikitaka.domain.colegiado.SegColegiado;
import es.tikitaka.domain.equipo.PartEquipo;
import es.tikitaka.domain.equipo.SegEquipo;
import es.tikitaka.domain.jugador.PartJugador;
import es.tikitaka.domain.jugador.SegJugador;
import es.tikitaka.domain.liga.CalendarioLiga;
import es.tikitaka.domain.liga.EstJornada;
import es.tikitaka.domain.liga.Jornada;
import es.tikitaka.domain.liga.PartidoL;

/**
 * 
 * @author Saúl Domínguez
 * @since 2010
 * @category PFC
 */

@Name("calendarAction")
@Scope(ScopeType.CONVERSATION)
public class CalendarAction {

	private CalendarioLiga calendar;
	private Temporada temporada;
	private Temporada temporadaConsulta;
	private Date fechaInicio;

	private int mode;

	private List<Temporada> listaTemporadas;
	private List<PartEquipo> listaEquiposPart;
	private List<PartColegiado> listaColegiadosPart;
	private Set<Jornada> jornadasCalendario;

	private PartEquipo eqDescansa;

	private List<Jornada> listaJornadas;
	private Jornada jornada;
	private int numJornada;
	private int numPartidosJornada;
	private Date fechaJornada;

	@DataModel("partidos")
	private List<PartidoL> mPartidos;
	@DataModelSelection("partidos")
	private PartidoL partidoL;

	@In(create = true)
	private TemporadaService temporadaService;

	@In(create = true)
	private PartEquipoService partEquipoService;

	@In(create = true)
	private SegEquipoService segEquipoService;

	@In(create = true)
	private PartColegiadoService partColegiadoService;

	@In(create = true)
	private SegColegiadoService segColegiadoService;

	@In(create = true)
	private SegJugadorService segJugadorService;

	@In(create = true)
	private CalendarioLigaService calendarioLigaService;

	@In(create = true)
	private JornadaService jornadaService;

	@In(create = true)
	private PartidoLService partidoLService;

	@In(create = true)
	private LigaService ligaService;

	@In(create = true)
	private CompeticionAction competicionAction;

	/**
	 * Constructor por defecto
	 */
	public CalendarAction() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * Método para comenzar la generación de un calendario
	 */
	public void crearCalendario() {
		calendar = new CalendarioLiga();
		listaTemporadas = temporadaService.getList();
	}

	/**
	 * Método para guardar y generar un calendario con los criterios
	 * establecidos
	 */
	@Begin(join = true, flushMode = FlushModeType.MANUAL)
	public void guardar() {
		if (comprobarTemporada()) {
			if (comprobarEquiposTemporada(temporada)) {
				if (comprobarColegiadosTemporada(temporada)) {
					// atributos del calendario
					boolean impar = false;
					int numEqMitad = 0;
					int numPartidos = 0;
					int numPartJornada = 0;
					int numJornadas = 0;
					Date fechaJornada = new Date();
					List<PartEquipo> equiposLocales = new ArrayList<PartEquipo>();
					List<PartEquipo> equiposVisitantes = new ArrayList<PartEquipo>();
					// fin atributos

					// se mira el número de equipos
					if (listaEquiposPart.size() % 2 != 0) {
						// número de equipos impar, va a haber uno que descanse
						// por jornada
						impar = true;
						eqDescansa = new PartEquipo();
						eqDescansa.setTemporada(temporada);
					} else {
						eqDescansa = null;
					}
					numEqMitad = listaEquiposPart.size() / 2;
					if (impar) {
						numEqMitad++;
					}
					for (int i = 0; i < numEqMitad; i++) {
						PartEquipo p = listaEquiposPart.get(i);
						p.setNumSorteo(i + 1);
						equiposLocales.add(p);
					}
					for (int i = numEqMitad; i < listaEquiposPart.size(); i++) {
						PartEquipo p = listaEquiposPart.get(i);
						p.setNumSorteo(i + 1);
						equiposVisitantes.add(listaEquiposPart.get(i));
					}
					if (impar) {
						eqDescansa.setNumSorteo(listaEquiposPart.size() + 1);
						equiposVisitantes.add(eqDescansa);
					}

					// cálculo del número de partidos totales del calendario
					numPartidos = calculaNumPartidos(listaEquiposPart.size());
					// cácluco del número de partidos por jornada
					numPartJornada = listaEquiposPart.size() / 2;
					// cálculo del número de jornadas
					numJornadas = numPartidos / numPartJornada;

					// creación de las jornadas que conformarán el calendario
					jornadasCalendario = new HashSet<Jornada>();
					for (int i = 0; i < numJornadas; i++) {
						Jornada j = new Jornada();
						j.setNumJor(i + 1);
						j.setCalendario(calendar);
						if (i == 0) {
							j.setFecha(fechaInicio);
							fechaJornada.setTime(proximaFecha(fechaInicio));
						} else {
							j.setFecha(fechaJornada);
							fechaJornada.setTime(proximaFecha(fechaJornada));
						}

						EstJornada ej = new EstJornada();
						j.setEstadisticas(ej);
						ej.setJornada(j);

						Set<PartidoL> partidosJornada = new HashSet<PartidoL>();
						List<PartEquipo> equipos1 = new ArrayList<PartEquipo>();
						List<PartEquipo> equipos2 = new ArrayList<PartEquipo>();

						if (j.getNumJor() % 2 != 0) {
							equipos1.addAll(equiposLocales);
							equipos2.addAll(equiposVisitantes);
						} else {
							equipos1.addAll(equiposVisitantes);
							equipos2.addAll(equiposLocales);
						}

						for (int p = 0; p < numPartJornada; p++) {
							PartidoL part = new PartidoL();
							Set<SegEquipo> equiposPart = new HashSet<SegEquipo>();
							SegEquipo local = new SegEquipo();
							SegEquipo visitante = new SegEquipo();
							SegColegiado arbitro = new SegColegiado();
							if (equipos1.get(p).getNumSorteo() == listaEquiposPart
									.size() + 1) {
								j.setDescansa(equiposLocales.get(p));
							} else if (equipos2.get(p).getNumSorteo() == listaEquiposPart
									.size() + 1) {
								j.setDescansa(equiposVisitantes.get(p));
							} else {
								local.setPartEquipo(equipos1.get(p));
								local.setPartido(part);
								visitante.setPartEquipo(equipos2.get(p));
								visitante.setPartido(part);
								equiposPart.add(local);
								equiposPart.add(visitante);
								arbitro.setPartColegiado(listaColegiadosPart
										.get(p));
								part.setM_equipos(equiposPart);
								part.setLocal(local.getPartEquipo().getEquipo()
										.getNombre());
								part.setVisitante(visitante.getPartEquipo()
										.getEquipo().getNombre());
								part.setColegiado(arbitro);
								part.setJornada(j);
								partidosJornada.add(part);
							}
						}
						j.setM_partidos(partidosJornada);
						jornadasCalendario.add(j);
						PartEquipo ultimo = equiposLocales.get(equiposLocales
								.size() - 1);
						PartEquipo primero = equiposVisitantes.get(0);
						equiposLocales.remove(ultimo);
						equiposVisitantes.remove(primero);
						equiposLocales.add(1, primero);
						equiposVisitantes.add(equiposVisitantes.size(), ultimo);
					}
					calendar.setM_jornadas(jornadasCalendario);
					if (guardarJornadas()) {
						if (calendarioLigaService.save(calendar)) {
							temporada.getLiga().setCalendario(calendar);
							if (ligaService.save(temporada.getLiga())) {
								if (temporadaService.save(temporada)) {
									FacesMessages
											.instance()
											.add(
													"El calendario para la temporada "
															+ temporada
																	.getAnio()
																	.getAnio()
															+ " ha sido creado correctamente");
								} else {
									FacesMessages
											.instance()
											.add(
													"Ha ocurrido un error en la creación del calendario a la hora de guardar los datos de la temporada");
								}
							} else {
								FacesMessages
										.instance()
										.add(
												"Ha ocurrido un errore en la creación del calendario a la hora de guardar los datos de la liga");
							}
						} else {
							FacesMessages
									.instance()
									.add(
											"Ha ocurrido un error en la creación del calendario");
						}
					} else {
						FacesMessages.instance().add(
								"Ha ocurrido un error guardando las jornadas");
					}
				}
			} else {
				FacesMessages
						.instance()
						.add(
								"Hay equipos que no cumplen con los requisitos (Mínimo de 8 jugadores por equipo)");
			}
		}
	}

	/**
	 * Método para guardar las jornadas que conforman el calendario de Liga para
	 * la temporada
	 * 
	 * @return true or false dependiendo de si se ha guardado bien o no
	 */
	@Begin(join = true, flushMode = FlushModeType.MANUAL)
	private boolean guardarJornadas() {
		boolean ok = true;

		// Se recorre todas las jornadas que conforman el calendario de liga
		Iterator<Jornada> it = jornadasCalendario.iterator();
		while (it.hasNext() && ok) {
			Jornada j = (Jornada) it.next();
			calendarioLigaService.persist(j.getCalendario());
			jornadaService.persist(j);
			// Para cada jornada j se guardan los partidos que la componen
			if (guardarPartidos(j.getM_partidos())) {
				// Si se han guardado correctamente los partidos, se procede a
				// guardar la jornada
				if (!jornadaService.save(j)) {
					ok = false;
					FacesMessages
							.instance()
							.add(
									"Se ha producido un error en el almacenamiento de las jornadas");
				}
			} else {
				ok = false;
				FacesMessages
						.instance()
						.add(
								"Se ha producido un error en el almacenamiento de los partidos");
			}
		}

		return ok;
	}

	/**
	 * Método para guardar los partidos que conforman una jornada de liga
	 * 
	 * @param m_partidos
	 *            Conjunto de partidos de liga que forman la jornada
	 * @return true or false dependiendo de si se ha guardado bien o no
	 */
	@Begin(join = true, flushMode = FlushModeType.MANUAL)
	private boolean guardarPartidos(Set<PartidoL> m_partidos) {
		boolean ok = true;
		// Se recorre todos los partidos que conforman una jornada de liga
		Iterator<PartidoL> it = m_partidos.iterator();
		while (it.hasNext() && ok) {
			PartidoL p = (PartidoL) it.next();
			partidoLService.persist(p);
			segColegiadoService.persist(p.getColegiado());
			// Para cada partido p se guardan los seguimientos de equipos
			if (guardaSeguimientosEquipos(p.getM_equipos())) {
				// Para cada partido p se guardan los seguimientos de colegiados
				if (guardaSeguimientoColegiado(p.getColegiado())) {
					// Si se han guardado correctamente los seguimientos, se
					// procede a guardar el partido en cuestion
					if (!partidoLService.save(p)) {
						ok = false;
						FacesMessages
								.instance()
								.add(
										"Se ha producido un error al guardar los partidos");
					}
				} else {
					ok = false;
					FacesMessages
							.instance()
							.add(
									"Se ha producido un error al guardar un seguimiento de colegiado");
				}
			} else {
				ok = false;
				FacesMessages
						.instance()
						.add(
								"Se ha producido un error al guardar los seguimientos de equipos");
			}
		}

		return ok;
	}

	/**
	 * Método para guardar el seguimiento del colegiado que arbitra un partido
	 * concreto
	 * 
	 * @param colegiado
	 *            Seguimiento de colegiado a guardar
	 * @return true or false dependiendo de si se ha guardado bien o no
	 */
	@Begin(join = true, flushMode = FlushModeType.MANUAL)
	private boolean guardaSeguimientoColegiado(SegColegiado colegiado) {
		boolean ok = true;
		if (!segColegiadoService.save(colegiado)) {
			ok = false;
		}
		return ok;
	}

	/**
	 * Método para guardar los seguimientos de equipos participantes en un
	 * partido
	 * 
	 * @param m_equipos
	 *            conjunto de equipos que participan en un partido
	 * @return true or false dependiendo de si se ha guardado bien o no
	 */
	@Begin(join = true, flushMode = FlushModeType.MANUAL)
	private boolean guardaSeguimientosEquipos(Set<SegEquipo> m_equipos) {
		boolean ok = true;

		// Se recorre los seguimientos de equipos participantes en un partido
		// para proceder a su almacenamiento
		Iterator<SegEquipo> it = m_equipos.iterator();
		while (it.hasNext() && ok) {
			SegEquipo s = (SegEquipo) it.next();
			segEquipoService.persist(s);
			boolean jugOk = true;
			// Para cada seguimiento de equipo se procede a recorrer el conjunto
			// de jugadores para almacenar los seguimientos de jugador
			Set<SegJugador> seguimientosJug = new HashSet<SegJugador>();
			Iterator<PartJugador> itj = s.getPartEquipo().getM_jugadores()
					.iterator();
			while (itj.hasNext() && jugOk) {
				PartJugador pj = (PartJugador) itj.next();
				// Para cada jugador (participación de jugador) se crea un
				// seguimiento para el partido en cuestión (más exactamente,
				// para el seguimiento de equipo en cuestion)
				SegJugador sj = new SegJugador();
				sj.setPartJugador(pj);
				sj.setSegEquipo(s);
				// Se añade el segJugador al conjunto de seguimientos
				seguimientosJug.add(sj);
				if (!segJugadorService.save(sj)) {
					jugOk = false;
					FacesMessages
							.instance()
							.add(
									"Se ha producido un error en la creación y almacenamiento de los seguimientos de jugadores");
				}
			}
			s.setM_jugadores(seguimientosJug);
			if (!segEquipoService.save(s)) {
				ok = false;
				FacesMessages
						.instance()
						.add(
								"Se ha producido un error en el alamacenamiento de los seguimientos de equipos");
			}

		}

		return ok;
	}

	/**
	 * Método para comprobar si una temporada ya tiene un calendario de liga
	 * asociado
	 * 
	 * @return true or false si la temporada no tiene calendario o si
	 */
	public boolean comprobarTemporada() {
		if (temporada != null) {
			if (temporada.getLiga().getCalendario() != null) {
				FacesMessages
						.instance()
						.add(
								"Esta temporada ya tiene un calendario de liga creado.");
				return false;
			} else {
				return true;
			}
		} else {
			return false;
		}
	}

	/**
	 * 
	 * @param tempo
	 * @return
	 */
	public boolean comprobarEquiposTemporada(Temporada tempo) {
		boolean ok = false;

		if (tempo != null) {
			listaEquiposPart = partEquipoService.getEquiposTemporada(tempo);
			if (listaEquiposPart != null && listaEquiposPart.size() > 7) {
				Iterator<PartEquipo> ite = listaEquiposPart.iterator();
				boolean numJugOk = true;
				while (ite.hasNext() && numJugOk) {
					PartEquipo eq = (PartEquipo) ite.next();
					if (eq.getM_jugadores() != null
							&& eq.getM_jugadores().size() < 8) {
						numJugOk = false;
						FacesMessages
								.instance()
								.add(
										"El equipo "
												+ eq.getEquipo().getNombre()
												+ " no tiene los 8 jugadores mínimo para participar.");
					}
				}

				ok = numJugOk;
			}
		}

		return ok;
	}

	/**
	 * 
	 * @param tempo
	 * @return
	 */
	public boolean comprobarColegiadosTemporada(Temporada tempo) {
		boolean ok = true;

		if (tempo != null) {
			listaColegiadosPart = partColegiadoService
					.getColegiadosTemporada(tempo);
			if (listaEquiposPart.size() / listaColegiadosPart.size() < 2) {
				ok = false;
			}
		}

		return ok;
	}

	/**
	 * 
	 * @param numEquipos
	 * @return
	 */
	private int calculaNumPartidos(int numEquipos) {

		int numPartidos = 0;
		int numEquiposPart = numEquipos - 2;

		numPartidos = ((factorial(numEquipos) / factorial(numEquiposPart)) / 2);

		return numPartidos;
	}

	private int factorial(int num) {
		if (num == 0)
			return 1;
		else
			return num * factorial(num - 1);

	}

	/**
	 * 
	 * @param fecha
	 * @return
	 */
	@SuppressWarnings("static-access")
	private long proximaFecha(Date fecha) {
		long prox = 0;
		GregorianCalendar c = new GregorianCalendar();

		c.setTimeInMillis(fecha.getTime());
		if (c.get(c.DAY_OF_WEEK) == 2 || c.get(c.DAY_OF_WEEK) == 4
				|| c.DAY_OF_WEEK == 7) {
			prox = fecha.getTime() + (2 * 24 * 60 * 60 * 1000);
		} else if (c.DAY_OF_WEEK == 1 || c.DAY_OF_WEEK == 3
				|| c.DAY_OF_WEEK == 5) {
			prox = fecha.getTime() + (1 * 24 * 60 * 60 * 1000);
		} else if (c.DAY_OF_WEEK == 6) {
			prox = fecha.getTime() + (3 * 24 * 60 * 60 * 1000);
		}

		return prox;
	}

	/**
	 * Método que carga los datos de un calendario de una temporada seleccionada
	 * previamente
	 * 
	 * @param temporada
	 */
	@Begin(join = true, flushMode = FlushModeType.MANUAL)
	public void selectCalendario(Temporada temporada) {
		if (temporada != null) {
			listaJornadas = new ArrayList<Jornada>();
			listaJornadas.addAll(temporada.getLiga().getCalendario()
					.getM_jornadas());
			numJornada = 1;
			// fechaJornada = mJornadas.get
		}
	}

	/**
	 * Método para cargar los datos del calendario de la temporada seleccionada
	 */
	@Begin(join = true)
	public void consultaCalendario(int mod) {
		if (temporadaConsulta != null) {
			this.temporada = temporadaConsulta;
			this.mode = mod;
			listaJornadas = new ArrayList<Jornada>();
			listaJornadas.addAll(temporada.getLiga().getCalendario()
					.getM_jornadas());
			Collections.sort(listaJornadas);
			mPartidos = new ArrayList<PartidoL>();
			jornada = new Jornada();
			jornada = listaJornadas.get(0);
			mPartidos.addAll(jornada.getM_partidos());
			numJornada = jornada.getNumJor();
			fechaJornada = jornada.getFecha();
		} else {
			FacesMessages
					.instance()
					.add(
							"Debe seleccionar una temporada para poder consultar un calendario");
		}
	}

	/**
	 * Método para cargar los datos del calendario de la temporada seleccionada
	 */
	@Begin(join = true)
	public void consultaPartidos(int mod) {
		if (temporada != null) {
			this.mode = mod;
			listaJornadas = new ArrayList<Jornada>();
			listaJornadas.addAll(temporada.getLiga().getCalendario()
					.getM_jornadas());
			Collections.sort(listaJornadas);
			mPartidos = new ArrayList<PartidoL>();
			jornada = new Jornada();
			jornada = listaJornadas.get(0);
			mPartidos.addAll(jornada.getM_partidos());
			numJornada = jornada.getNumJor();
			fechaJornada = jornada.getFecha();
		} else {
			FacesMessages
					.instance()
					.add(
							"Debe seleccionar una temporada para poder consultar un calendario");
		}
	}

	/**
	 * Método para cargar los datos de una jornada seleccionada
	 */
	@Begin(join = true)
	public void changeJornada() {
		if (jornada != null) {
			mPartidos.clear();
			mPartidos.addAll(jornada.getM_partidos());
			fechaJornada = jornada.getFecha();
		}
	}

	/**
	 * Método que da el estado del partido consultado (sin comenzar o
	 * finalizado)
	 * 
	 * @param par
	 * @return
	 */
	@Begin(join = true)
	public String consultaEstado(PartidoL par) {
		String estado = "";
		if (par != null) {
			if (par.isFin()) {
				estado = "finalizado";
			} else {
				estado = "sin comenzar";
			}
		}
		return estado;
	}

	/**
	 * Método que da el resultado del partido consultado
	 * 
	 * @param par
	 * @return
	 */
	@Begin(join = true)
	public String consultaResultado(PartidoL par) {
		StringBuffer resultado = new StringBuffer();
		resultado.append(par.getGolesL());
		resultado.append("-");
		resultado.append(par.getGolesV());
		return resultado.toString();
	}

	public void volver() {
		limpiar();
		competicionAction.cargaOpciones();
	}

	@End
	public void menu() {
		limpiar();
	}

	public void limpiar() {
		temporada = null;
		fechaInicio = null;
	}

	/*
	 * getters and setters
	 */

	/**
	 * 
	 * @return
	 */
	public CalendarioLiga getCalendar() {
		return calendar;
	}

	/**
	 * 
	 * @param calendar
	 */
	public void setCalendar(CalendarioLiga calendar) {
		this.calendar = calendar;
	}

	/**
	 * 
	 * @return
	 */
	public Temporada getTemporada() {
		return temporada;
	}

	/**
	 * 
	 * @param temporada
	 */
	public void setTemporada(Temporada temporada) {
		this.temporada = temporada;
	}

	/**
	 * 
	 * @return
	 */
	public Temporada getTemporadaConsulta() {
		return temporadaConsulta;
	}

	/**
	 * 
	 * @param temporadaConsulta
	 */
	public void setTemporadaConsulta(Temporada temporadaConsulta) {
		this.temporadaConsulta = temporadaConsulta;
	}

	/**
	 * 
	 * @return
	 */
	public Date getFechaInicio() {
		return fechaInicio;
	}

	/**
	 * 
	 * @param fechaInicio
	 */
	public void setFechaInicio(Date fechaInicio) {
		this.fechaInicio = fechaInicio;
	}

	/**
	 * 
	 * @return
	 */
	public int getMode() {
		return mode;
	}

	/**
	 * 
	 * @param mode
	 */
	public void setMode(int mode) {
		this.mode = mode;
	}

	/**
	 * 
	 * @return
	 */
	public List<Temporada> getListaTemporadas() {
		return listaTemporadas;
	}

	/**
	 * 
	 * @param listaTemporadas
	 */
	public void setListaTemporadas(List<Temporada> listaTemporadas) {
		this.listaTemporadas = listaTemporadas;
	}

	/**
	 * 
	 * @return
	 */
	public List<PartEquipo> getListaEquiposPart() {
		return listaEquiposPart;
	}

	/**
	 * 
	 * @param listaEquiposPart
	 */
	public void setListaEquiposPart(List<PartEquipo> listaEquiposPart) {
		this.listaEquiposPart = listaEquiposPart;
	}

	/**
	 * 
	 * @return
	 */
	public List<PartColegiado> getListaColegiadosPart() {
		return listaColegiadosPart;
	}

	/**
	 * 
	 * @param listaColegiadosPart
	 */
	public void setListaColegiadosPart(List<PartColegiado> listaColegiadosPart) {
		this.listaColegiadosPart = listaColegiadosPart;
	}

	/**
	 * 
	 * @return
	 */
	public Set<Jornada> getJornadasCalendario() {
		return jornadasCalendario;
	}

	/**
	 * 
	 * @param jornadasCalendario
	 */
	public void setJornadasCalendario(Set<Jornada> jornadasCalendario) {
		this.jornadasCalendario = jornadasCalendario;
	}

	/**
	 * 
	 * @return
	 */
	public PartEquipo getEqDescansa() {
		return eqDescansa;
	}

	/**
	 * 
	 * @param eqDescansa
	 */
	public void setEqDescansa(PartEquipo eqDescansa) {
		this.eqDescansa = eqDescansa;
	}

	/**
	 * 
	 * @return
	 */
	public List<Jornada> getListaJornadas() {
		return listaJornadas;
	}

	/**
	 * 
	 * @param listaJornadas
	 */
	public void setListaJornadas(List<Jornada> listaJornadas) {
		this.listaJornadas = listaJornadas;
	}

	/**
	 * 
	 * @return
	 */
	public Jornada getJornada() {
		return jornada;
	}

	/**
	 * 
	 * @param jornada
	 */
	public void setJornada(Jornada jornada) {
		this.jornada = jornada;
	}

	/**
	 * 
	 * @return
	 */
	public int getNumJornada() {
		return numJornada;
	}

	/**
	 * 
	 * @param numJornada
	 */
	public void setNumJornada(int numJornada) {
		this.numJornada = numJornada;
	}

	/**
	 * 
	 * @return
	 */
	public int getNumPartidosJornada() {
		return numPartidosJornada;
	}

	/**
	 * 
	 * @param numPartidosJornada
	 */
	public void setNumPartidosJornada(int numPartidosJornada) {
		this.numPartidosJornada = numPartidosJornada;
	}

	/**
	 * 
	 * @return
	 */
	public Date getFechaJornada() {
		return fechaJornada;
	}

	/**
	 * 
	 * @param fechaJornada
	 */
	public void setFechaJornada(Date fechaJornada) {
		this.fechaJornada = fechaJornada;
	}

	/**
	 * 
	 * @return
	 */
	public List<PartidoL> getMPartidos() {
		return mPartidos;
	}

	/**
	 * 
	 * @param partidos
	 */
	public void setMPartidos(List<PartidoL> partidos) {
		mPartidos = partidos;
	}

	/**
	 * 
	 * @return
	 */
	public PartidoL getPartidoL() {
		return partidoL;
	}

	/**
	 * 
	 * @param partidoL
	 */
	public void setPartidoL(PartidoL partidoL) {
		this.partidoL = partidoL;
	}
}
